
package zhang.lao.service.search;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.arronlong.httpclientutil.HttpClientUtil;
import com.arronlong.httpclientutil.common.HttpConfig;
import com.arronlong.httpclientutil.common.HttpHeader;
import com.arronlong.httpclientutil.exception.HttpProcessException;
import com.github.pagehelper.PageHelper;
import com.google.common.collect.Lists;
import org.apache.http.Header;
import org.codehaus.plexus.util.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import zhang.lao.build.mybatis.jdbc.auto.model.*;
import zhang.lao.build.tool.ListUtils;
import zhang.lao.build.tool.UUIDTool;
import zhang.lao.build.tool.date.DateStyle;
import zhang.lao.build.tool.date.DateUtil;
import zhang.lao.dao.base.WnLnglatGt06Dao;
import zhang.lao.dao.base.WnMachineDeviceDao;
import zhang.lao.dao.base.WnTableSynchronizationSearchDao;
import zhang.lao.pojo.ApiGt06PointReq;
import zhang.lao.pojo.ApiGt06PointResp;
import zhang.lao.pojo.console.resp.HttpResult;
import zhang.lao.pojo.console.resp.HttpResultEnum;
import zhang.lao.pojo.console.resp.HttpResultUtil;

import javax.annotation.Resource;
import java.util.List;

/**
 * Created by zhangqin on 2017/10/24.
 *//*

/**
 * @author
 * @create 2017-10-24 16:48
 **/


@Service
public class SearchService {
private static  final Logger logger = LoggerFactory.getLogger(SearchService.class);

private static boolean isRun = true;
    @Resource
    private WnLnglatGt06Dao wnLnglatGt06Dao;
    @Resource
    private WnMachineDeviceDao wnMachineDeviceDao;
    @Resource
    private WnTableSynchronizationSearchDao wnTableSynchronizationSearchDao;
    public static final List<Integer> tianjin = Lists.newArrayList(525,526,527,528,529,530,533,534,535,560,609,610);
    public static final List<Integer> xinjiang = Lists.newArrayList(17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,578,579,580,581,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,608);
    public HttpResult synLatLngToSearch() throws HttpProcessException {
        if(!isRun){
            System.out.println("定时任务--同步数据--------------任务未执行完毕");
            return HttpResultUtil.buildSuccess();
        }
        isRun=false;
        System.out.println("定时任务--同步数据--------------开始");
        try {
        WnTableSynchronizationSearchExample wnTableSynchronizationSearchExample = new WnTableSynchronizationSearchExample();
        wnTableSynchronizationSearchExample.setOrderByClause("last_time desc");
        PageHelper.startPage(1,1);
        WnTableSynchronizationSearch first = ListUtils.getFirst(wnTableSynchronizationSearchDao.selectByExample(wnTableSynchronizationSearchExample));
        WnLnglatGt06Example wnLnglatGt06Example = new WnLnglatGt06Example();
        if(first!=null){
            List<Integer> synTable = Lists.newArrayList();
            synTable.addAll(tianjin);
            synTable.addAll(xinjiang);
            wnLnglatGt06Example.createCriteria().andCreateTimeGreaterThan(first.getLastTime()).andDeviceIdIn(synTable);
        }

        wnLnglatGt06Example.setOrderByClause("create_time asc");
        PageHelper.startPage(1,50000);
        List<WnLnglatGt06> wnLnglatGt06s = wnLnglatGt06Dao.selectByExample(wnLnglatGt06Example);

        if(wnLnglatGt06s!=null&&wnLnglatGt06s.size()>0) {
            WnTableSynchronizationSearch wnTableSynchronizationSearch = new WnTableSynchronizationSearch();
            wnTableSynchronizationSearch.setId(UUIDTool.getUUID());
            wnTableSynchronizationSearch.setSynTableName("wn_lnglat_gt06");
            StringBuffer stringBuffer = new StringBuffer();

            for (WnLnglatGt06 wnLnglatGt06 : wnLnglatGt06s) {
                stringBuffer.append(" { \"index\" : { \"_index\" : \"wn_lnglat_gt06\", \"_type\" : \"gt06\" } } \r\n");
                stringBuffer.append(" {\"create_time\":\"" + DateUtil.DateToString(wnLnglatGt06.getCreateTime(), DateStyle.YYYY_MM_DD_HH_MM_SS) + "\",\"depth\":" + wnLnglatGt06.getDepth() + ",\"height\":" + wnLnglatGt06.getHeight() + ",\"lat\":" + wnLnglatGt06.getLat() + ",\"lng\":" + wnLnglatGt06.getLng() + ",\"orentation\":" + wnLnglatGt06.getOrentation() + ",\"speed\":" + wnLnglatGt06.getSpeed() + ",\"device_id\":" + wnLnglatGt06.getDeviceId() + "}\r\n");

                wnTableSynchronizationSearch.setLastTime(wnLnglatGt06.getCreateTime());

            }
            String url = "http://search.wncalbs.com/_bulk";
            Header[] headers 	= HttpHeader.custom()
                    .build();
            //插件式配置请求参数（网址、请求参数、编码、client）
            HttpConfig config = HttpConfig.custom()
                    .headers(headers)	//设置headers，不需要时则无需设置
                    .url(url)					//设置请求的url
                    .encoding("utf-8") //设置请求和返回编码，默认就是Charset.defaultCharset()
                    //.client(client)														//如果只是简单使用，无需设置，会自动获取默认的一个client对象
                    //.inenc("utf-8") 													//设置请求编码，如果请求返回一直，不需要再单独设置
                    //.inenc("utf-8")													//设置返回编码，如果请求返回一直，不需要再单独设置
                     .json(stringBuffer.toString())												//json方式请求的话，就不用设置map方法，当然二者可以共用。
                    //.context(HttpCookies.custom().getContext()) 		//设置cookie，用于完成携带cookie的操作
                    //.out(new FileOutputStream("保存地址"))			 	//下载的话，设置这个方法,否则不要设置
                    //.files(new String[]{"d:/1.txt","d:/2.txt"})					//上传的话，传递文件路径，一般还需map配置，设置服务器保存路径
                    ;
            String s = HttpClientUtil.post(config);
            wnTableSynchronizationSearchDao.insertSelective(wnTableSynchronizationSearch);
            System.out.println("定时任务--同步数据--------------结束");
            return HttpResultUtil.buildSuccess();
        }else{
            return HttpResultUtil.buildError(HttpResultEnum.FAIL);
        }
        }catch (Exception e){
            return HttpResultUtil.buildError(HttpResultEnum.FAIL);
        }finally {
            isRun=true;
        }
    }


    public HttpResult rounting() throws HttpProcessException {
        WnMachineDeviceExample wnMachineDeviceExample  = new WnMachineDeviceExample();
        wnMachineDeviceExample.createCriteria().andDeviceTypeEqualTo("gt06");
        List<WnMachineDevice> wnMachineDeviceList = wnMachineDeviceDao.selectByExample(wnMachineDeviceExample);
        for (WnMachineDevice wnMachineDevice : wnMachineDeviceList) {
            Integer id = wnMachineDevice.getId();

            String url = "http://search.wncalbs.com/wn_lnglat_gt06/gt06?routing="+id;
            Header[] headers 	= HttpHeader.custom()
                    .build();
            //插件式配置请求参数（网址、请求参数、编码、client）
            HttpConfig config = HttpConfig.custom()
                    .headers(headers)	//设置headers，不需要时则无需设置
                    .url(url)					//设置请求的url
                    .encoding("utf-8") //设置请求和返回编码，默认就是Charset.defaultCharset()
                    //.client(client)														//如果只是简单使用，无需设置，会自动获取默认的一个client对象
                    //.inenc("utf-8") 													//设置请求编码，如果请求返回一直，不需要再单独设置
                    //.inenc("utf-8")													//设置返回编码，如果请求返回一直，不需要再单独设置
                    .json("{  \n" +
                            "    \"productName\": \"deviceId\",  \n" +
                            "    \"deviceId\": \""+id+"\"\n" +
                            "}")												//json方式请求的话，就不用设置map方法，当然二者可以共用。
                    //.context(HttpCookies.custom().getContext()) 		//设置cookie，用于完成携带cookie的操作
                    //.out(new FileOutputStream("保存地址"))			 	//下载的话，设置这个方法,否则不要设置
                    //.files(new String[]{"d:/1.txt","d:/2.txt"})					//上传的话，传递文件路径，一般还需map配置，设置服务器保存路径
                    ;
          HttpClientUtil.post(config);
        }
        return HttpResultUtil.buildSuccess();
    }

    public HttpResult rounting( int deviceId) throws HttpProcessException {

            String url = "http://search.wncalbs.com/wn_lnglat_gt06/gt06?routing="+deviceId;
            Header[] headers 	= HttpHeader.custom()
                    .build();
            //插件式配置请求参数（网址、请求参数、编码、client）
            HttpConfig config = HttpConfig.custom()
                    .headers(headers)	//设置headers，不需要时则无需设置
                    .url(url)					//设置请求的url
                    .encoding("utf-8") //设置请求和返回编码，默认就是Charset.defaultCharset()
                    //.client(client)														//如果只是简单使用，无需设置，会自动获取默认的一个client对象
                    //.inenc("utf-8") 													//设置请求编码，如果请求返回一直，不需要再单独设置
                    //.inenc("utf-8")													//设置返回编码，如果请求返回一直，不需要再单独设置
                    .json("{  \n" +
                            "    \"productName\": \"deviceId\",  \n" +
                            "    \"deviceId\": \""+deviceId+"\"\n" +
                            "}")												//json方式请求的话，就不用设置map方法，当然二者可以共用。
                    //.context(HttpCookies.custom().getContext()) 		//设置cookie，用于完成携带cookie的操作
                    //.out(new FileOutputStream("保存地址"))			 	//下载的话，设置这个方法,否则不要设置
                    //.files(new String[]{"d:/1.txt","d:/2.txt"})					//上传的话，传递文件路径，一般还需map配置，设置服务器保存路径
                    ;
            HttpClientUtil.post(config);
        return HttpResultUtil.buildSuccess();
    }



    public List<ApiGt06PointResp>  gt06Resp(ApiGt06PointReq body) throws Exception {
        List<ApiGt06PointResp> list = Lists.newArrayList();
        int deviceId;
    if (StringUtils.isNotBlank(body.getDeviceId())){
        deviceId = Integer.parseInt(body.getDeviceId());
    }else {
        WnMachineDeviceExample wnMachineDeviceExample = new WnMachineDeviceExample();
        wnMachineDeviceExample.createCriteria().andDeviceNumberEqualTo(body.getDeviceNumber());
        WnMachineDevice wnMachineDevice = ListUtils.getFirst(wnMachineDeviceDao.selectByExample(wnMachineDeviceExample));
        if (wnMachineDevice == null) {
            return list;
        }
        deviceId = wnMachineDevice.getId();
    }
        String url = "http://search.wncalbs.com/wn_lnglat_gt06/_search?routing="+deviceId;
        Header[] headers 	= HttpHeader.custom()
                .build();
        //插件式配置请求参数（网址、请求参数、编码、client）
        HttpConfig config = HttpConfig.custom()
                .headers(headers)	//设置headers，不需要时则无需设置
                .url(url)					//设置请求的url
                .encoding("utf-8") //设置请求和返回编码，默认就是Charset.defaultCharset()
                //.client(client)														//如果只是简单使用，无需设置，会自动获取默认的一个client对象
                //.inenc("utf-8") 													//设置请求编码，如果请求返回一直，不需要再单独设置
                //.inenc("utf-8")													//设置返回编码，如果请求返回一直，不需要再单独设置
                .json("{\n" +
                        "  \"from\" : 0, \"size\" : 8640,\n" +
                        "\t\"query\": {\n" +
                        "    \"bool\": {\n" +
                        "      \"must\": [\n" +
                        "        { \"match\": { \"device_id\": \""+deviceId+"\" } } \n" +
                        "      ],\n" +
                        "         \"filter\": {\n" +
                        "        \"range\": {\n" +
                        "          \"create_time\": {\n" +
                        "         \t\t\"gt\":\""+body.getStartTime()+"\",\n" +
                        "\t\t\t\t\"lte\":\""+body.getEndTime()+"\"\n" +
                        "          }\n" +
                        "        }\n" +
                        "      }\n" +
                        "    }\n" +
                        "  },\n" +
                        "\t\"sort\":[{\n" +
                        "\t\t\"create_time\":{\"order\":\"asc\"}\n" +
                        "\t}]\n" +
                        "}")												//json方式请求的话，就不用设置map方法，当然二者可以共用。
                //.context(HttpCookies.custom().getContext()) 		//设置cookie，用于完成携带cookie的操作
                //.out(new FileOutputStream("保存地址"))			 	//下载的话，设置这个方法,否则不要设置
                //.files(new String[]{"d:/1.txt","d:/2.txt"})					//上传的话，传递文件路径，一般还需map配置，设置服务器保存路径
                ;
        String post = HttpClientUtil.post(config);
        JSONObject jsonObject =JSONObject.parseObject(post);
        JSONObject hits = jsonObject.getJSONObject("hits");
        JSONArray hits1 = hits.getJSONArray("hits");
        for (Object o : hits1) {
            JSONObject jsonObject1 = (JSONObject)o;
            JSONObject source = jsonObject1.getJSONObject("_source");
            source.put("createTime",source.getString("create_time"));
            source.remove("create_time");
            list.add(source.toJavaObject(ApiGt06PointResp.class));
        }
        return  list;
    }


}

